import os
import sys
import logging
import asyncio
from typing import List, Dict, Any

# 添加项目根目录到Python路径
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger('mock_data_verifier')

# 导入数据库和Shopify服务
from database.connection import get_session as get_db
from database.models import Product, Order, ShopifySyncLog
from sqlalchemy import select
from services.shopify_service import shopify_service
from services.sync_service import SyncService


async def verify_shopify_service_mode():
    """验证Shopify服务是否处于模拟数据模式"""
    logger.info("\n=== Shopify服务模式验证 ===")
    logger.info(f"服务启用状态: {shopify_service.enabled}")
    logger.info(f"使用模拟数据: {shopify_service.use_mock_data}")
    logger.info(f"强制模拟模式: {shopify_service.force_mock_mode}")
    
    if shopify_service.use_mock_data:
        logger.info("✅ Shopify服务当前正在使用模拟数据模式运行")
    else:
        logger.warning("⚠️ Shopify服务未使用模拟数据模式，可能会尝试连接真实API")
    
    return shopify_service.use_mock_data


async def test_manual_product_sync():
    """测试手动同步商品数据"""
    logger.info("\n=== 手动同步商品数据测试 ===")
    
    try:
        # 调用Shopify服务获取模拟商品
        logger.info("从Shopify服务获取模拟商品数据...")
        mock_products = await shopify_service.sync_products_from_shopify()
        
        logger.info(f"成功获取 {len(mock_products)} 个模拟商品")
        
        # 显示商品详情
        for i, product in enumerate(mock_products[:3]):
            logger.info(f"  商品 {i+1}: {product.get('title')} (价格: {product.get('price')})")
        
        # 调用同步服务将商品同步到数据库
        logger.info("\n将模拟商品同步到数据库...")
        sync_service = SyncService()
        await sync_service.sync_products()
        logger.info("商品同步完成")
        
        return True
        
    except Exception as e:
        logger.error(f"商品同步测试失败: {e}")
        import traceback
        traceback.print_exc()
        return False


async def test_manual_order_sync():
    """测试手动同步订单数据"""
    logger.info("\n=== 手动同步订单数据测试 ===")
    
    try:
        # 调用Shopify服务获取模拟订单
        logger.info("从Shopify服务获取模拟订单数据...")
        mock_orders = await shopify_service.sync_from_shopify()
        
        logger.info(f"成功获取 {len(mock_orders)} 个模拟订单")
        
        # 显示订单详情
        for i, order in enumerate(mock_orders[:3]):
            logger.info(f"  订单 {i+1}: {order.get('name')} (状态: {order.get('financial_status')})")
        
        # 调用同步服务将订单同步到数据库
        logger.info("\n将模拟订单同步到数据库...")
        sync_service = SyncService()
        await sync_service.sync_orders()
        logger.info("订单同步完成")
        
        return True
        
    except Exception as e:
        logger.error(f"订单同步测试失败: {e}")
        import traceback
        traceback.print_exc()
        return False


async def verify_database_data():
    """验证数据库中的模拟数据"""
    logger.info("\n=== 数据库数据验证 ===")
    
    async for db in get_db():
        # 检查模拟商品
        stmt = select(Product).where(Product.shopify_product_id.like('mock_product_%'))
        result = await db.execute(stmt)
        mock_products = result.scalars().all()
        
        logger.info(f"数据库中找到 {len(mock_products)} 个模拟商品")
        for product in mock_products[:3]:
            logger.info(f"  - {product.name} (价格: {product.price}, Shopify ID: {product.shopify_product_id})")
        
        # 检查模拟订单
        stmt = select(Order).where(Order.shopify_order_id.like('mock_order_%'))
        result = await db.execute(stmt)
        mock_orders = result.scalars().all()
        
        logger.info(f"数据库中找到 {len(mock_orders)} 个模拟订单")
        for order in mock_orders[:3]:
            logger.info(f"  - {order.order_number} (状态: {order.status}, Shopify ID: {order.shopify_order_id})")
        
        # 检查同步日志
        stmt = select(ShopifySyncLog).order_by(ShopifySyncLog.created_at.desc()).limit(5)
        result = await db.execute(stmt)
        sync_logs = result.scalars().all()
        
        logger.info(f"\n最近的同步日志:")
        for log in sync_logs:
            logger.info(f"  - {log.created_at} | {log.shopify_resource_type} | {log.shopify_operation} | {log.sync_status}")
        
        break


async def fix_async_generator_issue():
    """修复异步生成器错误"""
    logger.info("\n=== 修复异步生成器问题 ===")
    
    # 检查sync_service.py中的问题
    sync_service_path = os.path.join(
        os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
        'services', 'sync_service.py'
    )
    
    if not os.path.exists(sync_service_path):
        logger.error(f"未找到文件: {sync_service_path}")
        return False
    
    try:
        # 读取文件内容
        with open(sync_service_path, 'r', encoding='utf-8') as f:
            content = f.read()
        
        # 检查是否有使用异步上下文管理器的地方
        if 'async with' in content and 'get_db()' in content:
            logger.info("发现潜在的异步上下文管理器问题，提供修复建议")
            logger.info("\n修复建议:")
            logger.info("1. 将 async with get_db() as db: 改为:")
            logger.info("   async for db in get_db():")
            logger.info("      # 处理逻辑")
            logger.info("      break")
            
            # 自动修复文件
            new_content = content.replace(
                'async with get_db() as db:', 
                'async for db in get_db():'
            )
            
            # 添加break语句（简单实现，可能需要更复杂的逻辑）
            # 注意：这只是一个基本的修复，可能需要根据实际代码结构调整
            lines = new_content.split('\n')
            for i, line in enumerate(lines):
                if 'async for db in get_db():' in line:
                    # 找到下一个非空行的缩进级别
                    j = i + 1
                    while j < len(lines) and lines[j].strip() == '':
                        j += 1
                    
                    if j < len(lines):
                        indent = len(lines[j]) - len(lines[j].lstrip())
                        # 在适当的位置添加break（简单实现）
                        # 注意：这可能不是完美的修复，需要根据实际代码结构调整
                        for k in range(j, len(lines)):
                            if len(lines[k].strip()) > 0 and len(lines[k]) - len(lines[k].lstrip()) <= indent and k > j:
                                lines.insert(k, ' ' * indent + 'break')
                                break
            
            new_content = '\n'.join(lines)
            
            # 保存修复后的文件
            with open(sync_service_path, 'w', encoding='utf-8') as f:
                f.write(new_content)
            
            logger.info("✅ 已自动修复sync_service.py中的异步生成器问题")
            return True
        else:
            logger.info("未发现明显的异步上下文管理器问题")
            return False
            
    except Exception as e:
        logger.error(f"修复文件时出错: {e}")
        return False


async def main():
    """主测试函数"""
    logger.info("\n==========================================")
    logger.info("模拟数据同步验证工具")
    logger.info("==========================================")
    
    # 1. 验证Shopify服务模式
    is_mock_mode = await verify_shopify_service_mode()
    
    if not is_mock_mode:
        logger.warning("⚠️ Shopify服务未在模拟模式下运行，可能无法正确使用模拟数据")
        logger.warning("建议确保SHOPIFY_FORCE_MOCK_MODE=true环境变量已设置")
    
    # 2. 修复异步生成器问题
    await fix_async_generator_issue()
    
    # 3. 测试商品同步
    logger.info("\n开始测试数据同步...")
    
    # 延迟一下，确保修复生效
    await asyncio.sleep(1)
    
    # 4. 测试手动同步
    await test_manual_product_sync()
    await test_manual_order_sync()
    
    # 5. 验证数据库中的数据
    await verify_database_data()
    
    logger.info("\n==========================================")
    logger.info("验证完成！")
    logger.info("请访问 http://localhost:8000 查看管理页面上的模拟数据")
    logger.info("==========================================")


if __name__ == "__main__":
    asyncio.run(main())